home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / beans / XMLEncoder.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  7.8 KB  |  376 lines
  1. package java.beans;
  2.  
  3. import java.io.IOException;
  4. import java.io.OutputStream;
  5. import java.lang.reflect.Array;
  6. import java.lang.reflect.Field;
  7. import java.nio.charset.Charset;
  8. import java.nio.charset.CharsetEncoder;
  9. import java.util.IdentityHashMap;
  10. import java.util.Map;
  11. import java.util.Vector;
  12.  
  13. public class XMLEncoder extends Encoder {
  14.    private static String encoding = "UTF-8";
  15.    private OutputStream out;
  16.    private Object owner;
  17.    private int indentation = 0;
  18.    private boolean internal = false;
  19.    private Map valueToExpression;
  20.    private Map targetToStatementList;
  21.    private boolean preambleWritten = false;
  22.    private NameGenerator nameGenerator;
  23.  
  24.    public XMLEncoder(OutputStream var1) {
  25.       this.out = var1;
  26.       this.valueToExpression = new IdentityHashMap();
  27.       this.targetToStatementList = new IdentityHashMap();
  28.       this.nameGenerator = new NameGenerator();
  29.    }
  30.  
  31.    public void setOwner(Object var1) {
  32.       this.owner = var1;
  33.       this.writeExpression(new Expression(this, "getOwner", new Object[0]));
  34.    }
  35.  
  36.    public Object getOwner() {
  37.       return this.owner;
  38.    }
  39.  
  40.    public void writeObject(Object var1) {
  41.       if (this.internal) {
  42.          super.writeObject(var1);
  43.       } else {
  44.          this.writeStatement(new Statement(this, "writeObject", new Object[]{var1}));
  45.       }
  46.  
  47.    }
  48.  
  49.    private Vector statementList(Object var1) {
  50.       Vector var2 = (Vector)this.targetToStatementList.get(var1);
  51.       if (var2 != null) {
  52.          return var2;
  53.       } else {
  54.          var2 = new Vector();
  55.          this.targetToStatementList.put(var1, var2);
  56.          return var2;
  57.       }
  58.    }
  59.  
  60.    private void mark(Object var1, boolean var2) {
  61.       if (var1 != null && var1 != this) {
  62.          ValueData var3 = this.getValueData(var1);
  63.          Expression var4 = var3.exp;
  64.          if (var1.getClass() != String.class || var4 != null) {
  65.             if (var2) {
  66.                ++var3.refs;
  67.             }
  68.  
  69.             if (!var3.marked) {
  70.                var3.marked = true;
  71.                Object var5 = var4.getTarget();
  72.                if (!(var5 instanceof Class)) {
  73.                   this.statementList(var5).add(var4);
  74.                   ++var3.refs;
  75.                }
  76.  
  77.                this.mark(var4);
  78.             }
  79.          }
  80.       }
  81.    }
  82.  
  83.    private void mark(Statement var1) {
  84.       Object[] var2 = var1.getArguments();
  85.  
  86.       for(int var3 = 0; var3 < var2.length; ++var3) {
  87.          Object var4 = var2[var3];
  88.          this.mark(var4, true);
  89.       }
  90.  
  91.       this.mark(var1.getTarget(), false);
  92.    }
  93.  
  94.    public void writeStatement(Statement var1) {
  95.       boolean var2 = this.internal;
  96.       this.internal = true;
  97.  
  98.       try {
  99.          super.writeStatement(var1);
  100.          this.mark(var1);
  101.          this.statementList(var1.getTarget()).add(var1);
  102.       } catch (Exception var4) {
  103.          this.getExceptionListener().exceptionThrown(new Exception("XMLEncoder: discarding statement " + var1, var4));
  104.       }
  105.  
  106.       this.internal = var2;
  107.    }
  108.  
  109.    public void writeExpression(Expression var1) {
  110.       boolean var2 = this.internal;
  111.       this.internal = true;
  112.       Object var3 = this.getValue(var1);
  113.       if (this.get(var3) == null || var3 instanceof String && !var2) {
  114.          this.getValueData(var3).exp = var1;
  115.          super.writeExpression(var1);
  116.       }
  117.  
  118.       this.internal = var2;
  119.    }
  120.  
  121.    public void flush() {
  122.       if (!this.preambleWritten) {
  123.          this.writeln("<?xml version=" + this.quote("1.0") + " encoding=" + this.quote(encoding) + "?>");
  124.          this.writeln("<java version=" + this.quote(System.getProperty("java.version")) + " class=" + this.quote(XMLDecoder.class.getName()) + ">");
  125.          this.preambleWritten = true;
  126.       }
  127.  
  128.       ++this.indentation;
  129.       Vector var1 = this.statementList(this);
  130.  
  131.       for(int var2 = 0; var2 < var1.size(); ++var2) {
  132.          Statement var3 = (Statement)var1.get(var2);
  133.          if ("writeObject".equals(var3.getMethodName())) {
  134.             this.outputValue(var3.getArguments()[0], this, true);
  135.          } else {
  136.             this.outputStatement(var3, this, false);
  137.          }
  138.       }
  139.  
  140.       --this.indentation;
  141.  
  142.       try {
  143.          this.out.flush();
  144.       } catch (IOException var4) {
  145.          this.getExceptionListener().exceptionThrown(var4);
  146.       }
  147.  
  148.       this.clear();
  149.    }
  150.  
  151.    void clear() {
  152.       super.clear();
  153.       this.nameGenerator.clear();
  154.       this.valueToExpression.clear();
  155.       this.targetToStatementList.clear();
  156.    }
  157.  
  158.    public void close() {
  159.       this.flush();
  160.       this.writeln("</java>");
  161.  
  162.       try {
  163.          this.out.close();
  164.       } catch (IOException var2) {
  165.          this.getExceptionListener().exceptionThrown(var2);
  166.       }
  167.  
  168.    }
  169.  
  170.    private String quote(String var1) {
  171.       return "\"" + var1 + "\"";
  172.    }
  173.  
  174.    private ValueData getValueData(Object var1) {
  175.       ValueData var2 = (ValueData)this.valueToExpression.get(var1);
  176.       if (var2 == null) {
  177.          var2 = new ValueData(this, (1)null);
  178.          this.valueToExpression.put(var1, var2);
  179.       }
  180.  
  181.       return var2;
  182.    }
  183.  
  184.    private static boolean isValidCharCode(int var0) {
  185.       return 32 <= var0 && var0 <= 55295 || 10 == var0 || 9 == var0 || 13 == var0 || 57344 <= var0 && var0 <= 65533 || 65536 <= var0 && var0 <= 1114111;
  186.    }
  187.  
  188.    private void writeln(String var1) {
  189.       try {
  190.          for(int var2 = 0; var2 < this.indentation; ++var2) {
  191.             this.out.write(32);
  192.          }
  193.  
  194.          this.out.write(var1.getBytes(encoding));
  195.          this.out.write(" \n".getBytes(encoding));
  196.       } catch (IOException var3) {
  197.          this.getExceptionListener().exceptionThrown(var3);
  198.       }
  199.  
  200.    }
  201.  
  202.    private void outputValue(Object var1, Object var2, boolean var3) {
  203.       if (var1 == null) {
  204.          this.writeln("<null/>");
  205.       } else if (var1 instanceof Class) {
  206.          this.writeln("<class>" + ((Class)var1).getName() + "</class>");
  207.       } else {
  208.          ValueData var4 = this.getValueData(var1);
  209.          if (var4.exp != null) {
  210.             Object var5 = var4.exp.getTarget();
  211.             String var6 = var4.exp.getMethodName();
  212.             if (var5 == null || var6 == null) {
  213.                throw new NullPointerException((var5 == null ? "target" : "methodName") + " should not be null");
  214.             }
  215.  
  216.             if (var5 instanceof Field && var6.equals("get")) {
  217.                Field var10 = (Field)var5;
  218.                this.writeln("<object class=" + this.quote(var10.getDeclaringClass().getName()) + " field=" + this.quote(var10.getName()) + "/>");
  219.                return;
  220.             }
  221.  
  222.             Class var7 = ReflectionUtils.primitiveTypeFor(var1.getClass());
  223.             if (var7 != null && var5 == var1.getClass() && var6.equals("new")) {
  224.                String var8 = var7.getName();
  225.                if (var7 == Character.TYPE) {
  226.                   char var9 = (Character)var1;
  227.                   if (!isValidCharCode(var9)) {
  228.                      this.writeln(createString(var9));
  229.                      return;
  230.                   }
  231.  
  232.                   var1 = quoteCharCode(var9);
  233.                   if (var1 == null) {
  234.                      var1 = var9;
  235.                   }
  236.                }
  237.  
  238.                this.writeln("<" + var8 + ">" + var1 + "</" + var8 + ">");
  239.                return;
  240.             }
  241.          } else if (var1 instanceof String) {
  242.             this.writeln(this.createString((String)var1));
  243.             return;
  244.          }
  245.  
  246.          if (var4.name != null) {
  247.             this.writeln("<object idref=" + this.quote(var4.name) + "/>");
  248.          } else {
  249.             this.outputStatement(var4.exp, var2, var3);
  250.          }
  251.       }
  252.    }
  253.  
  254.    private static String quoteCharCode(int var0) {
  255.       switch (var0) {
  256.          case 13:
  257.             return " ";
  258.          case 34:
  259.             return """;
  260.          case 38:
  261.             return "&";
  262.          case 39:
  263.             return "'";
  264.          case 60:
  265.             return "<";
  266.          case 62:
  267.             return ">";
  268.          default:
  269.             return null;
  270.       }
  271.    }
  272.  
  273.    private static String createString(int var0) {
  274.       return "<char code=\"#" + Integer.toString(var0, 16) + "\"/>";
  275.    }
  276.  
  277.    private String createString(String var1) {
  278.       CharsetEncoder var2 = Charset.forName(encoding).newEncoder();
  279.       StringBuilder var3 = new StringBuilder();
  280.       var3.append("<string>");
  281.       int var4 = 0;
  282.  
  283.       while(var4 < var1.length()) {
  284.          int var5 = var1.codePointAt(var4);
  285.          int var6 = Character.charCount(var5);
  286.          if (isValidCharCode(var5) && var2.canEncode(var1.substring(var4, var4 + var6))) {
  287.             String var7 = quoteCharCode(var5);
  288.             if (var7 != null) {
  289.                var3.append(var7);
  290.             } else {
  291.                var3.appendCodePoint(var5);
  292.             }
  293.  
  294.             var4 += var6;
  295.          } else {
  296.             var3.append(createString(var1.charAt(var4)));
  297.             ++var4;
  298.          }
  299.       }
  300.  
  301.       var3.append("</string>");
  302.       return var3.toString();
  303.    }
  304.  
  305.    private void outputStatement(Statement var1, Object var2, boolean var3) {
  306.       Object var4 = var1.getTarget();
  307.       String var5 = var1.getMethodName();
  308.       if (var4 != null && var5 != null) {
  309.          Object[] var6 = var1.getArguments();
  310.          boolean var7 = var1.getClass() == Expression.class;
  311.          Object var8 = var7 ? this.getValue((Expression)var1) : null;
  312.          String var9 = var7 && var3 ? "object" : "void";
  313.          String var10 = "";
  314.          ValueData var11 = this.getValueData(var8);
  315.          if (var7 && var11.refs > 1) {
  316.             String var12 = this.nameGenerator.instanceName(var8);
  317.             var11.name = var12;
  318.             var10 = var10 + " id=" + this.quote(var12);
  319.          }
  320.  
  321.          if (var4 != var2) {
  322.             if (var4 == Array.class && var5.equals("newInstance")) {
  323.                var9 = "array";
  324.                var10 = var10 + " class=" + this.quote(((Class)var6[0]).getName());
  325.                var10 = var10 + " length=" + this.quote(var6[1].toString());
  326.                var6 = new Object[0];
  327.             } else {
  328.                if (var4.getClass() != Class.class) {
  329.                   var11.refs = 2;
  330.                   this.outputValue(var4, var2, false);
  331.                   this.outputValue(var8, var2, false);
  332.                   return;
  333.                }
  334.  
  335.                var10 = var10 + " class=" + this.quote(((Class)var4).getName());
  336.             }
  337.          }
  338.  
  339.          if ((var7 || !var5.equals("set") || var6.length != 2 || !(var6[0] instanceof Integer)) && (!var7 || !var5.equals("get") || var6.length != 1 || !(var6[0] instanceof Integer))) {
  340.             if ((var7 || !var5.startsWith("set") || var6.length != 1) && (!var7 || !var5.startsWith("get") || var6.length != 0)) {
  341.                if (!var5.equals("new") && !var5.equals("newInstance")) {
  342.                   var10 = var10 + " method=" + this.quote(var5);
  343.                }
  344.             } else {
  345.                var10 = var10 + " property=" + this.quote(Introspector.decapitalize(var5.substring(3)));
  346.             }
  347.          } else {
  348.             var10 = var10 + " index=" + this.quote(var6[0].toString());
  349.             var6 = var6.length == 1 ? new Object[0] : new Object[]{var6[1]};
  350.          }
  351.  
  352.          Vector var16 = this.statementList(var8);
  353.          if (var6.length == 0 && var16.size() == 0) {
  354.             this.writeln("<" + var9 + var10 + "/>");
  355.          } else {
  356.             this.writeln("<" + var9 + var10 + ">");
  357.             ++this.indentation;
  358.  
  359.             for(int var13 = 0; var13 < var6.length; ++var13) {
  360.                this.outputValue(var6[var13], (Object)null, true);
  361.             }
  362.  
  363.             for(int var17 = 0; var17 < var16.size(); ++var17) {
  364.                Statement var14 = (Statement)var16.get(var17);
  365.                this.outputStatement(var14, var8, false);
  366.             }
  367.  
  368.             --this.indentation;
  369.             this.writeln("</" + var9 + ">");
  370.          }
  371.       } else {
  372.          throw new NullPointerException((var4 == null ? "target" : "methodName") + " should not be null");
  373.       }
  374.    }
  375. }
  376.